﻿#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLuaBase.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class WorldEntryWrap 
    {
        public static void __Register(RealStatePtr L)
        {
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.Type type = typeof(WorldEntry);
			Utils.BeginObjectRegister(type, L, translator, 0, 31, 3, 3);
			
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMapPointState", _m_SetMapPointState);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetAdorn", _m_ResetAdorn);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAllianceChunck", _m_SetAllianceChunck);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMapPointCheck", _m_SetMapPointCheck);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowMapPoint", _m_ShowMapPoint);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowAllianceBuildPoint", _m_ShowAllianceBuildPoint);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMapPointInView", _m_GetMapPointInView);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckTerrainCollider", _m_CheckTerrainCollider);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCameraGridSize", _m_SetCameraGridSize);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddCameraLODGridRange", _m_AddCameraLODGridRange);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddWorldMapData", _m_AddWorldMapData);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetLayerRect", _m_ResetLayerRect);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLodStrategy", _m_GetLodStrategy);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTileTraffic", _m_AddTileTraffic);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveTileTraffic", _m_RemoveTileTraffic);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCarNum", _m_SetCarNum);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCarCheck", _m_SetCarCheck);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTrafficEnabled", _m_SetTrafficEnabled);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTrafficOpen", _m_SetTrafficOpen);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Create", _m_Create);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLODLevel", _m_GetLODLevel);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLODPercent", _m_GetLODPercent);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLayerContainer", _m_GetLayerContainer);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLightState", _m_GetLightState);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetSandboxDecorationQuality", _m_ResetSandboxDecorationQuality);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCamera", _m_GetCamera);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayNormalBackMusic", _m_PlayNormalBackMusic);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayBattleBackMusic", _m_PlayBattleBackMusic);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSceneType", _m_SetSceneType);
			
			
			Utils.RegisterFunc(L, Utils.GETTER_IDX, "m_LODArray", _g_get_m_LODArray);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "_alliancePointSystem", _g_get__alliancePointSystem);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "_mapPointAdornSystem", _g_get__mapPointAdornSystem);
            
			Utils.RegisterFunc(L, Utils.SETTER_IDX, "m_LODArray", _s_set_m_LODArray);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "_alliancePointSystem", _s_set__alliancePointSystem);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "_mapPointAdornSystem", _s_set__mapPointAdornSystem);
            
			
			Utils.EndObjectRegister(type, L, translator, null, null,
			    null, null, null);

		    Utils.BeginClassRegister(type, L, __CreateInstance, 29, 24, 24);
			Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapPointState", _m_GetMapPointState_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetShowMapType", _m_GetShowMapType_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAllianceChunck", _m_GetAllianceChunck_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapPointCheck", _m_GetMapPointCheck_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLayerSizeByLod", _m_GetLayerSizeByLod_xlua_st_);
            
			
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MarchLodLevelCount", WorldEntry.MarchLodLevelCount);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MarchLodLevels", WorldEntry.MarchLodLevels);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MarchLodPercents", WorldEntry.MarchLodPercents);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PLANE_LAYER_NAME", WorldEntry.PLANE_LAYER_NAME);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TREE_LAYER_NAME", WorldEntry.TREE_LAYER_NAME);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MOUNTAIN_LAYER_NAME", WorldEntry.MOUNTAIN_LAYER_NAME);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MOUNTAINRANGE_LAYER_NAME", WorldEntry.MOUNTAINRANGE_LAYER_NAME);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DECORATION_LAYER_NAME", WorldEntry.DECORATION_LAYER_NAME);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TRAFFIC_LAYER_NAME", WorldEntry.TRAFFIC_LAYER_NAME);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAP_POINT_NAME", WorldEntry.MAP_POINT_NAME);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ALLIANCEPOINT_ROAD_LAYER_NAME", WorldEntry.ALLIANCEPOINT_ROAD_LAYER_NAME);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ALLIANCEPOINT_CROSS_LAYER_NAME", WorldEntry.ALLIANCEPOINT_CROSS_LAYER_NAME);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAP_POINT_ADORN_LAYER_NAME", WorldEntry.MAP_POINT_ADORN_LAYER_NAME);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PLANE_LAYER_ID", WorldEntry.PLANE_LAYER_ID);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MOUNTAINRANGE_LAYER_ID", WorldEntry.MOUNTAINRANGE_LAYER_ID);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TREE_LAYER_ID", WorldEntry.TREE_LAYER_ID);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MOUNTAIN_LAYER_ID", WorldEntry.MOUNTAIN_LAYER_ID);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DECORATION_LAYER_ID", WorldEntry.DECORATION_LAYER_ID);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TRAFFIC_LAYER_ID", WorldEntry.TRAFFIC_LAYER_ID);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAP_POINT_ID", WorldEntry.MAP_POINT_ID);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ALLIANCEPOINT_ROAD_LAYER_ID", WorldEntry.ALLIANCEPOINT_ROAD_LAYER_ID);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ALLIANCEPOINT_CROSS_LAYER_ID", WorldEntry.ALLIANCEPOINT_CROSS_LAYER_ID);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAP_POINT_ADORN_LAYER_ID", WorldEntry.MAP_POINT_ADORN_LAYER_ID);
            
			Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "instance", _g_get_instance);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "UpdateSwitch", _g_get_UpdateSwitch);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DISTANCE_LOD0", _g_get_DISTANCE_LOD0);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DISTANCE_LOD1", _g_get_DISTANCE_LOD1);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DISTANCE_LOD2", _g_get_DISTANCE_LOD2);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DISTANCE_LOD3", _g_get_DISTANCE_LOD3);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DISTANCE_LOD4", _g_get_DISTANCE_LOD4);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DISTANCE_LOD5", _g_get_DISTANCE_LOD5);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "MaxShowMarchLodLevel", _g_get_MaxShowMarchLodLevel);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "TreeShadowMaxLod", _g_get_TreeShadowMaxLod);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ViewRectScaleRatio", _g_get_ViewRectScaleRatio);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "bMapPointShow", _g_get_bMapPointShow);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "bMapPointCheck", _g_get_bMapPointCheck);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "m_iTileSize", _g_get_m_iTileSize);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "m_mapSize", _g_get_m_mapSize);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "m_mapLandSize", _g_get_m_mapLandSize);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "m_overSeaSize", _g_get_m_overSeaSize);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "m_seaSize", _g_get_m_seaSize);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "m_mapDataSize", _g_get_m_mapDataSize);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "m_mapDataOffset", _g_get_m_mapDataOffset);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "resPointOffset", _g_get_resPointOffset);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "MapShowAdornPointType", _g_get_MapShowAdornPointType);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "showMapType", _g_get_showMapType);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "allianceChuncks", _g_get_allianceChuncks);
            
			Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "instance", _s_set_instance);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "UpdateSwitch", _s_set_UpdateSwitch);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DISTANCE_LOD0", _s_set_DISTANCE_LOD0);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DISTANCE_LOD1", _s_set_DISTANCE_LOD1);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DISTANCE_LOD2", _s_set_DISTANCE_LOD2);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DISTANCE_LOD3", _s_set_DISTANCE_LOD3);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DISTANCE_LOD4", _s_set_DISTANCE_LOD4);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DISTANCE_LOD5", _s_set_DISTANCE_LOD5);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "MaxShowMarchLodLevel", _s_set_MaxShowMarchLodLevel);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "TreeShadowMaxLod", _s_set_TreeShadowMaxLod);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ViewRectScaleRatio", _s_set_ViewRectScaleRatio);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "bMapPointShow", _s_set_bMapPointShow);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "bMapPointCheck", _s_set_bMapPointCheck);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "m_iTileSize", _s_set_m_iTileSize);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "m_mapSize", _s_set_m_mapSize);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "m_mapLandSize", _s_set_m_mapLandSize);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "m_overSeaSize", _s_set_m_overSeaSize);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "m_seaSize", _s_set_m_seaSize);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "m_mapDataSize", _s_set_m_mapDataSize);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "m_mapDataOffset", _s_set_m_mapDataOffset);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "resPointOffset", _s_set_resPointOffset);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "MapShowAdornPointType", _s_set_MapShowAdornPointType);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "showMapType", _s_set_showMapType);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "allianceChuncks", _s_set_allianceChuncks);
            
			
            Utils.RegisterFunc(L, Utils.CLS_IDX, "New", __CreateInstanceNew);
			Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable<WorldMapBase.Camera.ICamera>(L, 2))
				{
					WorldMapBase.Camera.ICamera _camera = (WorldMapBase.Camera.ICamera)translator.GetObject(L, 2, typeof(WorldMapBase.Camera.ICamera));
					
					var gen_ret = new WorldEntry(_camera);
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to WorldEntry constructor!");
            
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstanceNew(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 1 && translator.Assignable<WorldMapBase.Camera.ICamera>(L, 1))
				{
					WorldMapBase.Camera.ICamera _camera = (WorldMapBase.Camera.ICamera)translator.GetObject(L, 1, typeof(WorldMapBase.Camera.ICamera));
					
					var gen_ret = new WorldEntry(_camera);
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to WorldEntry constructor!");
            
        }

        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMapPointState(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 9&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) || LuaAPI.lua_isint64(L, 7))&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)) 
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 2);
                    int _posIdx = LuaAPI.xlua_tointeger(L, 3);
                    bool _state = LuaAPI.lua_toboolean(L, 4);
                    bool _disAdorn = LuaAPI.lua_toboolean(L, 5);
                    int _type = LuaAPI.xlua_tointeger(L, 6);
                    long _allianceId = LuaAPI.lua_toint64(L, 7);
                    float _point_x = (float)LuaAPI.lua_tonumber(L, 8);
                    float _point_y = (float)LuaAPI.lua_tonumber(L, 9);
                    
                    gen_to_be_invoked.SetMapPointState( _tileIdx, _posIdx, _state, _disAdorn, _type, _allianceId, _point_x, _point_y );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 8&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) || LuaAPI.lua_isint64(L, 7))&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)) 
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 2);
                    int _posIdx = LuaAPI.xlua_tointeger(L, 3);
                    bool _state = LuaAPI.lua_toboolean(L, 4);
                    bool _disAdorn = LuaAPI.lua_toboolean(L, 5);
                    int _type = LuaAPI.xlua_tointeger(L, 6);
                    long _allianceId = LuaAPI.lua_toint64(L, 7);
                    float _point_x = (float)LuaAPI.lua_tonumber(L, 8);
                    
                    gen_to_be_invoked.SetMapPointState( _tileIdx, _posIdx, _state, _disAdorn, _type, _allianceId, _point_x );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 7&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) || LuaAPI.lua_isint64(L, 7))) 
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 2);
                    int _posIdx = LuaAPI.xlua_tointeger(L, 3);
                    bool _state = LuaAPI.lua_toboolean(L, 4);
                    bool _disAdorn = LuaAPI.lua_toboolean(L, 5);
                    int _type = LuaAPI.xlua_tointeger(L, 6);
                    long _allianceId = LuaAPI.lua_toint64(L, 7);
                    
                    gen_to_be_invoked.SetMapPointState( _tileIdx, _posIdx, _state, _disAdorn, _type, _allianceId );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) 
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 2);
                    int _posIdx = LuaAPI.xlua_tointeger(L, 3);
                    bool _state = LuaAPI.lua_toboolean(L, 4);
                    bool _disAdorn = LuaAPI.lua_toboolean(L, 5);
                    int _type = LuaAPI.xlua_tointeger(L, 6);
                    
                    gen_to_be_invoked.SetMapPointState( _tileIdx, _posIdx, _state, _disAdorn, _type );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) 
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 2);
                    int _posIdx = LuaAPI.xlua_tointeger(L, 3);
                    bool _state = LuaAPI.lua_toboolean(L, 4);
                    bool _disAdorn = LuaAPI.lua_toboolean(L, 5);
                    
                    gen_to_be_invoked.SetMapPointState( _tileIdx, _posIdx, _state, _disAdorn );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to WorldEntry.SetMapPointState!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ResetAdorn(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.ResetAdorn(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapPointState_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 1);
                    int _posIdx = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = WorldEntry.GetMapPointState( _tileIdx, _posIdx );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetShowMapType_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _type = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldEntry.GetShowMapType( _type );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetAllianceChunck(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _tileIndex = LuaAPI.xlua_tointeger(L, 2);
                    bool _value = LuaAPI.lua_toboolean(L, 3);
                    
                    gen_to_be_invoked.SetAllianceChunck( _tileIndex, _value );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetAllianceChunck_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _tileIndex = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldEntry.GetAllianceChunck( _tileIndex );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMapPointCheck(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _enabled = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetMapPointCheck( _enabled );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapPointCheck_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                        var gen_ret = WorldEntry.GetMapPointCheck(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowMapPoint(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _enabled = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.ShowMapPoint( _enabled );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowAllianceBuildPoint(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _enabled = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.ShowAllianceBuildPoint( _enabled );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapPointInView(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetMapPointInView(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckTerrainCollider(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    UnityEngine.Vector3 _pos;translator.Get(L, 2, out _pos);
                    float _r = (float)LuaAPI.lua_tonumber(L, 3);
                    int _layerMask = LuaAPI.xlua_tointeger(L, 4);
                    
                        var gen_ret = gen_to_be_invoked.CheckTerrainCollider( _pos, _r, _layerMask );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetCameraGridSize(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _width = LuaAPI.xlua_tointeger(L, 2);
                    int _height = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.SetCameraGridSize( _width, _height );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddCameraLODGridRange(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _lodLevel = LuaAPI.xlua_tointeger(L, 2);
                    int _gridRow = LuaAPI.xlua_tointeger(L, 3);
                    int _gridCol = LuaAPI.xlua_tointeger(L, 4);
                    
                    gen_to_be_invoked.AddCameraLODGridRange( _lodLevel, _gridRow, _gridCol );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddWorldMapData(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    WorldMapNew.WorldMapData _worldMapData = (WorldMapNew.WorldMapData)translator.GetObject(L, 2, typeof(WorldMapNew.WorldMapData));
                    
                    gen_to_be_invoked.AddWorldMapData( _worldMapData );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ResetLayerRect(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    WorldMapNew.WorldMapData _worldMapData = (WorldMapNew.WorldMapData)translator.GetObject(L, 2, typeof(WorldMapNew.WorldMapData));
                    
                    gen_to_be_invoked.ResetLayerRect( _worldMapData );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetLodStrategy(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetLodStrategy(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddTileTraffic(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 2);
                    int _lod = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.AddTileTraffic( _tileIdx, _lod );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RemoveTileTraffic(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 2);
                    int _lod = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.RemoveTileTraffic( _tileIdx, _lod );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetCarNum(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _carNum = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.SetCarNum( _carNum );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetCarCheck(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _isCarCheck = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetCarCheck( _isCarCheck );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetTrafficEnabled(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _isEnabled = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetTrafficEnabled( _isEnabled );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetTrafficOpen(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _isEnabled = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetTrafficOpen( _isEnabled );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Create(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.Create(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Destroy(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.Destroy(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Update(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.Update(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetLODLevel(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetLODLevel(  );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetLODPercent(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetLODPercent(  );
                        LuaAPI.lua_pushnumber(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetLayerContainer(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _layerId = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = gen_to_be_invoked.GetLayerContainer( _layerId );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetLightState(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 2);
                    int _nodeId = LuaAPI.xlua_tointeger(L, 3);
                    int _sideId1 = LuaAPI.xlua_tointeger(L, 4);
                    int _sideId2 = LuaAPI.xlua_tointeger(L, 5);
                    
                        var gen_ret = gen_to_be_invoked.GetLightState( _tileIdx, _nodeId, _sideId1, _sideId2 );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ResetSandboxDecorationQuality(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _level = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.ResetSandboxDecorationQuality( _level );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetCamera(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetCamera(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayNormalBackMusic(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.PlayNormalBackMusic(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayBattleBackMusic(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.PlayBattleBackMusic(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetLayerSizeByLod_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _layerId = LuaAPI.xlua_tointeger(L, 1);
                    int _lod = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = WorldEntry.GetLayerSizeByLod( _layerId, _lod );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetSceneType(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _sceneType = LuaAPI.xlua_tointeger(L, 2);
                    XLua.LuaFunction _luaFunc = (XLua.LuaFunction)translator.GetObject(L, 3, typeof(XLua.LuaFunction));
                    
                    gen_to_be_invoked.SetSceneType( _sceneType, _luaFunc );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_instance(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, WorldEntry.instance);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_UpdateSwitch(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, WorldEntry.UpdateSwitch);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_DISTANCE_LOD0(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, WorldEntry.DISTANCE_LOD0);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_DISTANCE_LOD1(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, WorldEntry.DISTANCE_LOD1);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_DISTANCE_LOD2(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, WorldEntry.DISTANCE_LOD2);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_DISTANCE_LOD3(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, WorldEntry.DISTANCE_LOD3);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_DISTANCE_LOD4(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, WorldEntry.DISTANCE_LOD4);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_DISTANCE_LOD5(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, WorldEntry.DISTANCE_LOD5);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_MaxShowMarchLodLevel(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldEntry.MaxShowMarchLodLevel);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_TreeShadowMaxLod(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldEntry.TreeShadowMaxLod);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ViewRectScaleRatio(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, WorldEntry.ViewRectScaleRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_m_LODArray(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.m_LODArray);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_bMapPointShow(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, WorldEntry.bMapPointShow);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_bMapPointCheck(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, WorldEntry.bMapPointCheck);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_m_iTileSize(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldEntry.m_iTileSize);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_m_mapSize(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldEntry.m_mapSize);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_m_mapLandSize(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldEntry.m_mapLandSize);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_m_overSeaSize(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldEntry.m_overSeaSize);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_m_seaSize(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldEntry.m_seaSize);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_m_mapDataSize(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldEntry.m_mapDataSize);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_m_mapDataOffset(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldEntry.m_mapDataOffset);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get__alliancePointSystem(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked._alliancePointSystem);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get__mapPointAdornSystem(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked._mapPointAdornSystem);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_resPointOffset(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushnumber(L, WorldEntry.resPointOffset);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_MapShowAdornPointType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, WorldEntry.MapShowAdornPointType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_showMapType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, WorldEntry.showMapType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_allianceChuncks(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, WorldEntry.allianceChuncks);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_instance(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    WorldEntry.instance = (WorldEntry)translator.GetObject(L, 1, typeof(WorldEntry));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_UpdateSwitch(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.UpdateSwitch = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_DISTANCE_LOD0(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.DISTANCE_LOD0 = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_DISTANCE_LOD1(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.DISTANCE_LOD1 = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_DISTANCE_LOD2(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.DISTANCE_LOD2 = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_DISTANCE_LOD3(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.DISTANCE_LOD3 = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_DISTANCE_LOD4(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.DISTANCE_LOD4 = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_DISTANCE_LOD5(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.DISTANCE_LOD5 = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_MaxShowMarchLodLevel(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.MaxShowMarchLodLevel = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_TreeShadowMaxLod(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.TreeShadowMaxLod = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_ViewRectScaleRatio(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.ViewRectScaleRatio = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_m_LODArray(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.m_LODArray = (float[])translator.GetObject(L, 2, typeof(float[]));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_bMapPointShow(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.bMapPointShow = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_bMapPointCheck(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.bMapPointCheck = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_m_iTileSize(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.m_iTileSize = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_m_mapSize(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.m_mapSize = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_m_mapLandSize(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.m_mapLandSize = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_m_overSeaSize(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.m_overSeaSize = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_m_seaSize(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.m_seaSize = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_m_mapDataSize(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.m_mapDataSize = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_m_mapDataOffset(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.m_mapDataOffset = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set__alliancePointSystem(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked._alliancePointSystem = (MapAlliancePointSystem)translator.GetObject(L, 2, typeof(MapAlliancePointSystem));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set__mapPointAdornSystem(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                WorldEntry gen_to_be_invoked = (WorldEntry)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked._mapPointAdornSystem = (MapPointAdornSystem)translator.GetObject(L, 2, typeof(MapPointAdornSystem));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_resPointOffset(RealStatePtr L)
        {
		    try {
                
			    WorldEntry.resPointOffset = (float)LuaAPI.lua_tonumber(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_MapShowAdornPointType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    WorldEntry.MapShowAdornPointType = (System.Collections.Generic.List<int>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<int>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_showMapType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    WorldEntry.showMapType = (System.Collections.Generic.Dictionary<int, bool>)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary<int, bool>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_allianceChuncks(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    WorldEntry.allianceChuncks = (System.Collections.Generic.Dictionary<int, bool>)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary<int, bool>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
		
		
		
		
    }
}
